home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 March / PCWMAR09.iso / Software / Freeware / Adobe Media Player 1.6 / adobe_media_player.air / AMP.swf / scripts / mx / controls / ComboBox.as < prev    next >
Encoding:
Text File  |  2008-11-25  |  33.1 KB  |  1,065 lines
  1. package mx.controls
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.FocusEvent;
  6.    import flash.events.KeyboardEvent;
  7.    import flash.events.MouseEvent;
  8.    import flash.geom.Point;
  9.    import flash.geom.Rectangle;
  10.    import flash.text.TextLineMetrics;
  11.    import flash.ui.Keyboard;
  12.    import mx.collections.ArrayCollection;
  13.    import mx.collections.CursorBookmark;
  14.    import mx.controls.dataGridClasses.DataGridListData;
  15.    import mx.controls.listClasses.BaseListData;
  16.    import mx.controls.listClasses.IDropInListItemRenderer;
  17.    import mx.controls.listClasses.IListItemRenderer;
  18.    import mx.controls.listClasses.ListBase;
  19.    import mx.controls.listClasses.ListData;
  20.    import mx.core.ClassFactory;
  21.    import mx.core.EdgeMetrics;
  22.    import mx.core.FlexVersion;
  23.    import mx.core.IDataRenderer;
  24.    import mx.core.IFactory;
  25.    import mx.core.ScrollPolicy;
  26.    import mx.core.UIComponent;
  27.    import mx.core.UIComponentGlobals;
  28.    import mx.core.mx_internal;
  29.    import mx.effects.Tween;
  30.    import mx.events.CollectionEvent;
  31.    import mx.events.CollectionEventKind;
  32.    import mx.events.DropdownEvent;
  33.    import mx.events.FlexEvent;
  34.    import mx.events.FlexMouseEvent;
  35.    import mx.events.InterManagerRequest;
  36.    import mx.events.ListEvent;
  37.    import mx.events.SandboxMouseEvent;
  38.    import mx.events.ScrollEvent;
  39.    import mx.events.ScrollEventDetail;
  40.    import mx.managers.ISystemManager;
  41.    import mx.managers.PopUpManager;
  42.    import mx.styles.CSSStyleDeclaration;
  43.    import mx.styles.StyleManager;
  44.    
  45.    use namespace mx_internal;
  46.    
  47.    public class ComboBox extends ComboBase implements IDataRenderer, IDropInListItemRenderer, IListItemRenderer
  48.    {
  49.       mx_internal static var createAccessibilityImplementation:Function;
  50.       
  51.       mx_internal static const VERSION:String = "3.2.0.3958";
  52.       
  53.       private var _labelField:String = "label";
  54.       
  55.       private var dropdownBorderStyle:String = "solid";
  56.       
  57.       private var implicitSelectedIndex:Boolean = false;
  58.       
  59.       private var _selectedIndexOnDropdown:int = -1;
  60.       
  61.       private var preferredDropdownWidth:Number;
  62.       
  63.       private var collectionChanged:Boolean = false;
  64.       
  65.       private var labelFunctionChanged:Boolean;
  66.       
  67.       private var selectedItemSet:Boolean;
  68.       
  69.       private var _dropdownWidth:Number = 100;
  70.       
  71.       private var inTween:Boolean = false;
  72.       
  73.       private var _oldIndex:int;
  74.       
  75.       private var tweenUp:Boolean = false;
  76.       
  77.       private var tween:Tween = null;
  78.       
  79.       private var labelFieldChanged:Boolean;
  80.       
  81.       private var _dropdown:ListBase;
  82.       
  83.       private var _dropdownFactory:IFactory;
  84.       
  85.       private var explicitText:Boolean;
  86.       
  87.       private var _prompt:String;
  88.       
  89.       private var _data:Object;
  90.       
  91.       private var bInKeyDown:Boolean = false;
  92.       
  93.       private var promptChanged:Boolean = false;
  94.       
  95.       private var _rowCount:int = 5;
  96.       
  97.       private var bRemoveDropdown:Boolean = false;
  98.       
  99.       private var _showingDropdown:Boolean = false;
  100.       
  101.       private var triggerEvent:Event;
  102.       
  103.       private var _listData:BaseListData;
  104.       
  105.       private var _itemRenderer:IFactory;
  106.       
  107.       private var _labelFunction:Function;
  108.       
  109.       public function ComboBox()
  110.       {
  111.          _dropdownFactory = new ClassFactory(List);
  112.          super();
  113.          dataProvider = new ArrayCollection();
  114.          mx_internal::useFullDropdownSkin = true;
  115.          mx_internal::wrapDownArrowButton = false;
  116.          addEventListener("unload",unloadHandler);
  117.          addEventListener(Event.REMOVED_FROM_STAGE,removedFromStageHandler);
  118.       }
  119.       
  120.       override protected function calculatePreferredSizeFromData(param1:int) : Object
  121.       {
  122.          var _loc6_:TextLineMetrics = null;
  123.          var _loc8_:Object = null;
  124.          var _loc9_:String = null;
  125.          var _loc2_:Number = 0;
  126.          var _loc3_:Number = 0;
  127.          var _loc4_:CursorBookmark = !!iterator ? iterator.bookmark : null;
  128.          iterator.seek(CursorBookmark.FIRST,0);
  129.          var _loc5_:* = iterator != null;
  130.          var _loc7_:int = 0;
  131.          while(_loc7_ < param1)
  132.          {
  133.             if(_loc5_)
  134.             {
  135.                _loc8_ = !!iterator ? iterator.current : null;
  136.             }
  137.             else
  138.             {
  139.                _loc8_ = null;
  140.             }
  141.             _loc9_ = itemToLabel(_loc8_);
  142.             _loc6_ = measureText(_loc9_);
  143.             _loc2_ = Math.max(_loc2_,_loc6_.width);
  144.             _loc3_ = Math.max(_loc3_,_loc6_.height);
  145.             if(iterator)
  146.             {
  147.                iterator.moveNext();
  148.             }
  149.             _loc7_++;
  150.          }
  151.          if(prompt)
  152.          {
  153.             _loc6_ = measureText(prompt);
  154.             _loc2_ = Math.max(_loc2_,_loc6_.width);
  155.             _loc3_ = Math.max(_loc3_,_loc6_.height);
  156.          }
  157.          _loc2_ += getStyle("paddingLeft") + getStyle("paddingRight");
  158.          if(iterator)
  159.          {
  160.             iterator.seek(_loc4_,0);
  161.          }
  162.          return {
  163.             "width":_loc2_,
  164.             "height":_loc3_
  165.          };
  166.       }
  167.       
  168.       private function dropdown_scrollHandler(param1:Event) : void
  169.       {
  170.          var _loc2_:ScrollEvent = null;
  171.          if(param1 is ScrollEvent)
  172.          {
  173.             _loc2_ = ScrollEvent(param1);
  174.             if(_loc2_.detail == ScrollEventDetail.THUMB_TRACK || _loc2_.detail == ScrollEventDetail.THUMB_POSITION || _loc2_.detail == ScrollEventDetail.LINE_UP || _loc2_.detail == ScrollEventDetail.LINE_DOWN)
  175.             {
  176.                dispatchEvent(_loc2_);
  177.             }
  178.          }
  179.       }
  180.       
  181.       public function get dropdown() : ListBase
  182.       {
  183.          return getDropdown();
  184.       }
  185.       
  186.       public function get selectedLabel() : String
  187.       {
  188.          var _loc1_:Object = selectedItem;
  189.          return itemToLabel(_loc1_);
  190.       }
  191.       
  192.       override protected function focusOutHandler(param1:FocusEvent) : void
  193.       {
  194.          if(_showingDropdown && Boolean(_dropdown))
  195.          {
  196.             if(!param1.relatedObject || !_dropdown.contains(param1.relatedObject))
  197.             {
  198.                close();
  199.             }
  200.          }
  201.          super.focusOutHandler(param1);
  202.       }
  203.       
  204.       private function popup_moveHandler(param1:Event) : void
  205.       {
  206.          destroyDropdown();
  207.       }
  208.       
  209.       private function destroyDropdown() : void
  210.       {
  211.          if(Boolean(_dropdown) && !_showingDropdown)
  212.          {
  213.             if(inTween)
  214.             {
  215.                tween.endTween();
  216.             }
  217.             else
  218.             {
  219.                PopUpManager.removePopUp(_dropdown);
  220.                _dropdown = null;
  221.             }
  222.          }
  223.       }
  224.       
  225.       [Bindable("dropdownWidthChanged")]
  226.       public function get dropdownWidth() : Number
  227.       {
  228.          return _dropdownWidth;
  229.       }
  230.       
  231.       private function unloadHandler(param1:Event) : void
  232.       {
  233.          if(inTween)
  234.          {
  235.             UIComponent.resumeBackgroundProcessing();
  236.             inTween = false;
  237.          }
  238.          if(_dropdown)
  239.          {
  240.             _dropdown.parent.removeChild(_dropdown);
  241.          }
  242.       }
  243.       
  244.       public function open() : void
  245.       {
  246.          displayDropdown(true);
  247.       }
  248.       
  249.       public function set data(param1:Object) : void
  250.       {
  251.          var _loc2_:* = undefined;
  252.          _data = param1;
  253.          if(Boolean(_listData) && _listData is DataGridListData)
  254.          {
  255.             _loc2_ = _data[DataGridListData(_listData).dataField];
  256.          }
  257.          else if(_listData is ListData && ListData(_listData).labelField in _data)
  258.          {
  259.             _loc2_ = _data[ListData(_listData).labelField];
  260.          }
  261.          else
  262.          {
  263.             _loc2_ = _data;
  264.          }
  265.          if(_loc2_ !== undefined && !selectedItemSet)
  266.          {
  267.             selectedItem = _loc2_;
  268.             selectedItemSet = false;
  269.          }
  270.          dispatchEvent(new FlexEvent(FlexEvent.DATA_CHANGE));
  271.       }
  272.       
  273.       [Bindable("resize")]
  274.       public function get rowCount() : int
  275.       {
  276.          return Math.max(1,Math.min(collection.length,_rowCount));
  277.       }
  278.       
  279.       override protected function textInput_changeHandler(param1:Event) : void
  280.       {
  281.          super.textInput_changeHandler(param1);
  282.          dispatchChangeEvent(param1,-1,-2);
  283.       }
  284.       
  285.       private function dropdown_itemRollOutHandler(param1:Event) : void
  286.       {
  287.          dispatchEvent(param1);
  288.       }
  289.       
  290.       override protected function measure() : void
  291.       {
  292.          super.measure();
  293.          measuredMinWidth = Math.max(measuredWidth,DEFAULT_MEASURED_MIN_WIDTH);
  294.          var _loc1_:Number = measureText("M").height + 6;
  295.          var _loc2_:EdgeMetrics = borderMetrics;
  296.          measuredMinHeight = measuredHeight = Math.max(_loc1_ + _loc2_.top + _loc2_.bottom,DEFAULT_MEASURED_MIN_HEIGHT);
  297.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  298.          {
  299.             measuredMinHeight = measuredHeight = measuredHeight + (getStyle("paddingTop") + getStyle("paddingBottom"));
  300.          }
  301.       }
  302.       
  303.       private function dropdown_itemRollOverHandler(param1:Event) : void
  304.       {
  305.          dispatchEvent(param1);
  306.       }
  307.       
  308.       public function get prompt() : String
  309.       {
  310.          return _prompt;
  311.       }
  312.       
  313.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  314.       {
  315.          var _loc2_:int = 0;
  316.          if(!enabled)
  317.          {
  318.             return;
  319.          }
  320.          if(param1.target == textInput)
  321.          {
  322.             return;
  323.          }
  324.          if(param1.ctrlKey && param1.keyCode == Keyboard.DOWN)
  325.          {
  326.             displayDropdown(true,param1);
  327.             param1.stopPropagation();
  328.          }
  329.          else if(param1.ctrlKey && param1.keyCode == Keyboard.UP)
  330.          {
  331.             close(param1);
  332.             param1.stopPropagation();
  333.          }
  334.          else if(param1.keyCode == Keyboard.ESCAPE)
  335.          {
  336.             if(_showingDropdown)
  337.             {
  338.                if(_oldIndex != _dropdown.selectedIndex)
  339.                {
  340.                   selectedIndex = _oldIndex;
  341.                }
  342.                displayDropdown(false);
  343.                param1.stopPropagation();
  344.             }
  345.          }
  346.          else if(param1.keyCode == Keyboard.ENTER)
  347.          {
  348.             if(_showingDropdown)
  349.             {
  350.                close();
  351.                param1.stopPropagation();
  352.             }
  353.          }
  354.          else if(!editable || param1.keyCode == Keyboard.UP || param1.keyCode == Keyboard.DOWN || param1.keyCode == Keyboard.PAGE_UP || param1.keyCode == Keyboard.PAGE_DOWN)
  355.          {
  356.             _loc2_ = selectedIndex;
  357.             bInKeyDown = _showingDropdown;
  358.             dropdown.dispatchEvent(param1.clone());
  359.             param1.stopPropagation();
  360.             bInKeyDown = false;
  361.          }
  362.       }
  363.       
  364.       public function set dropdownWidth(param1:Number) : void
  365.       {
  366.          _dropdownWidth = param1;
  367.          preferredDropdownWidth = param1;
  368.          if(_dropdown)
  369.          {
  370.             _dropdown.setActualSize(param1,_dropdown.height);
  371.          }
  372.          dispatchEvent(new Event("dropdownWidthChanged"));
  373.       }
  374.       
  375.       [Bindable("labelFieldChanged")]
  376.       public function get labelField() : String
  377.       {
  378.          return _labelField;
  379.       }
  380.       
  381.       public function set dropdownFactory(param1:IFactory) : void
  382.       {
  383.          _dropdownFactory = param1;
  384.          dispatchEvent(new Event("dropdownFactoryChanged"));
  385.       }
  386.       
  387.       [Bindable("collectionChange")]
  388.       override public function set dataProvider(param1:Object) : void
  389.       {
  390.          mx_internal::selectionChanged = true;
  391.          super.dataProvider = param1;
  392.          destroyDropdown();
  393.          _showingDropdown = false;
  394.          invalidateProperties();
  395.          invalidateSize();
  396.       }
  397.       
  398.       mx_internal function get isShowingDropdown() : Boolean
  399.       {
  400.          return _showingDropdown;
  401.       }
  402.       
  403.       override protected function collectionChangeHandler(param1:Event) : void
  404.       {
  405.          var _loc3_:CollectionEvent = null;
  406.          var _loc2_:int = selectedIndex;
  407.          super.collectionChangeHandler(param1);
  408.          if(param1 is CollectionEvent)
  409.          {
  410.             _loc3_ = CollectionEvent(param1);
  411.             if(collection.length == 0)
  412.             {
  413.                if(!mx_internal::selectedIndexChanged && !mx_internal::selectedItemChanged)
  414.                {
  415.                   if(super.selectedIndex != -1)
  416.                   {
  417.                      super.selectedIndex = -1;
  418.                   }
  419.                   implicitSelectedIndex = true;
  420.                   invalidateDisplayList();
  421.                }
  422.                if(Boolean(textInput) && !editable)
  423.                {
  424.                   textInput.text = "";
  425.                }
  426.             }
  427.             else if(_loc3_.kind == CollectionEventKind.ADD)
  428.             {
  429.                if(collection.length != _loc3_.items.length)
  430.                {
  431.                   return;
  432.                }
  433.                if(selectedIndex == -1 && _prompt == null)
  434.                {
  435.                   selectedIndex = 0;
  436.                }
  437.             }
  438.             else if(_loc3_.kind == CollectionEventKind.UPDATE)
  439.             {
  440.                if(_loc3_.location == selectedIndex || _loc3_.items[0].source == selectedItem)
  441.                {
  442.                   mx_internal::selectionChanged = true;
  443.                }
  444.             }
  445.             else
  446.             {
  447.                if(_loc3_.kind == CollectionEventKind.REPLACE)
  448.                {
  449.                   return;
  450.                }
  451.                if(_loc3_.kind == CollectionEventKind.RESET)
  452.                {
  453.                   collectionChanged = true;
  454.                   if(!mx_internal::selectedIndexChanged && !mx_internal::selectedItemChanged)
  455.                   {
  456.                      selectedIndex = !!prompt ? -1 : 0;
  457.                   }
  458.                   invalidateProperties();
  459.                }
  460.             }
  461.             invalidateDisplayList();
  462.             destroyDropdown();
  463.             _showingDropdown = false;
  464.          }
  465.       }
  466.       
  467.       mx_internal function onTweenEnd(param1:Number) : void
  468.       {
  469.          if(_dropdown)
  470.          {
  471.             _dropdown.scrollRect = null;
  472.             inTween = false;
  473.             _dropdown.enabled = true;
  474.             _dropdown.visible = _showingDropdown;
  475.          }
  476.          if(bRemoveDropdown)
  477.          {
  478.             _dropdown.removeEventListener(FlexMouseEvent.MOUSE_DOWN_OUTSIDE,dropdown_mouseOutsideHandler);
  479.             _dropdown.removeEventListener(FlexMouseEvent.MOUSE_WHEEL_OUTSIDE,dropdown_mouseOutsideHandler);
  480.             _dropdown.removeEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE,dropdown_mouseOutsideHandler);
  481.             _dropdown.removeEventListener(SandboxMouseEvent.MOUSE_WHEEL_SOMEWHERE,dropdown_mouseOutsideHandler);
  482.             PopUpManager.removePopUp(_dropdown);
  483.             _dropdown = null;
  484.             bRemoveDropdown = false;
  485.          }
  486.          UIComponent.resumeBackgroundProcessing();
  487.          var _loc2_:DropdownEvent = new DropdownEvent(_showingDropdown ? DropdownEvent.OPEN : DropdownEvent.CLOSE);
  488.          _loc2_.triggerEvent = triggerEvent;
  489.          dispatchEvent(_loc2_);
  490.       }
  491.       
  492.       [Bindable("dataChange")]
  493.       public function get listData() : BaseListData
  494.       {
  495.          return _listData;
  496.       }
  497.       
  498.       private function getDropdown() : ListBase
  499.       {
  500.          var _loc1_:String = null;
  501.          var _loc2_:CSSStyleDeclaration = null;
  502.          if(!initialized)
  503.          {
  504.             return null;
  505.          }
  506.          if(!mx_internal::hasDropdown())
  507.          {
  508.             _loc1_ = getStyle("dropDownStyleName");
  509.             if(_loc1_ == null)
  510.             {
  511.                _loc1_ = getStyle("dropdownStyleName");
  512.             }
  513.             _dropdown = dropdownFactory.newInstance();
  514.             _dropdown.visible = false;
  515.             _dropdown.focusEnabled = false;
  516.             _dropdown.owner = this;
  517.             if(itemRenderer)
  518.             {
  519.                _dropdown.itemRenderer = itemRenderer;
  520.             }
  521.             if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  522.             {
  523.                _dropdown.styleName = this;
  524.             }
  525.             if(_loc1_)
  526.             {
  527.                if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  528.                {
  529.                   _loc2_ = StyleManager.getStyleDeclaration("." + _loc1_);
  530.                   if(_loc2_)
  531.                   {
  532.                      _dropdown.styleDeclaration = _loc2_;
  533.                   }
  534.                }
  535.                else
  536.                {
  537.                   _dropdown.styleName = _loc1_;
  538.                }
  539.             }
  540.             else if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  541.             {
  542.                _dropdown.setStyle("cornerRadius",0);
  543.             }
  544.             PopUpManager.addPopUp(_dropdown,this);
  545.             _dropdown.setStyle("selectionDuration",0);
  546.             if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0 && dropdownBorderStyle && dropdownBorderStyle != "")
  547.             {
  548.                _dropdown.setStyle("borderStyle",dropdownBorderStyle);
  549.             }
  550.             if(!dataProvider)
  551.             {
  552.                dataProvider = new ArrayCollection();
  553.             }
  554.             _dropdown.dataProvider = dataProvider;
  555.             _dropdown.rowCount = rowCount;
  556.             _dropdown.width = _dropdownWidth;
  557.             _dropdown.selectedIndex = selectedIndex;
  558.             _oldIndex = selectedIndex;
  559.             _dropdown.verticalScrollPolicy = ScrollPolicy.AUTO;
  560.             _dropdown.labelField = _labelField;
  561.             _dropdown.labelFunction = _labelFunction;
  562.             _dropdown.allowDragSelection = true;
  563.             _dropdown.addEventListener("change",dropdown_changeHandler);
  564.             _dropdown.addEventListener(ScrollEvent.SCROLL,dropdown_scrollHandler);
  565.             _dropdown.addEventListener(ListEvent.ITEM_ROLL_OVER,dropdown_itemRollOverHandler);
  566.             _dropdown.addEventListener(ListEvent.ITEM_ROLL_OUT,dropdown_itemRollOutHandler);
  567.             _dropdown.addEventListener(ListEvent.ITEM_CLICK,dropdown_itemClickHandler);
  568.             UIComponentGlobals.mx_internal::layoutManager.validateClient(_dropdown,true);
  569.             _dropdown.setActualSize(_dropdownWidth,_dropdown.getExplicitOrMeasuredHeight());
  570.             _dropdown.validateDisplayList();
  571.             _dropdown.cacheAsBitmap = true;
  572.             systemManager.addEventListener(Event.RESIZE,stage_resizeHandler,false,0,true);
  573.          }
  574.          _dropdown.scaleX = scaleX;
  575.          _dropdown.scaleY = scaleY;
  576.          return _dropdown;
  577.       }
  578.       
  579.       private function stage_resizeHandler(param1:Event) : void
  580.       {
  581.          if(_dropdown)
  582.          {
  583.             _dropdown.mx_internal::$visible = false;
  584.             _showingDropdown = false;
  585.          }
  586.       }
  587.       
  588.       override protected function downArrowButton_buttonDownHandler(param1:FlexEvent) : void
  589.       {
  590.          if(_showingDropdown)
  591.          {
  592.             close(param1);
  593.          }
  594.          else
  595.          {
  596.             displayDropdown(true,param1);
  597.          }
  598.       }
  599.       
  600.       [Bindable("valueCommit")]
  601.       [Bindable("collectionChange")]
  602.       [Bindable("change")]
  603.       override public function set selectedItem(param1:Object) : void
  604.       {
  605.          selectedItemSet = true;
  606.          super.selectedItem = param1;
  607.       }
  608.       
  609.       override protected function initializeAccessibility() : void
  610.       {
  611.          if(ComboBox.mx_internal::createAccessibilityImplementation != null)
  612.          {
  613.             ComboBox.mx_internal::createAccessibilityImplementation(this);
  614.          }
  615.       }
  616.       
  617.       public function itemToLabel(param1:Object) : String
  618.       {
  619.          var item:Object = param1;
  620.          if(item == null)
  621.          {
  622.             return "";
  623.          }
  624.          if(labelFunction != null)
  625.          {
  626.             return labelFunction(item);
  627.          }
  628.          if(typeof item == "object")
  629.          {
  630.             try
  631.             {
  632.                if(item[labelField] != null)
  633.                {
  634.                   item = item[labelField];
  635.                }
  636.             }
  637.             catch(e:Error)
  638.             {
  639.             }
  640.          }
  641.          else if(typeof item == "xml")
  642.          {
  643.             try
  644.             {
  645.                if(item[labelField].length() != 0)
  646.                {
  647.                   item = item[labelField];
  648.                }
  649.             }
  650.             catch(e:Error)
  651.             {
  652.             }
  653.          }
  654.          if(typeof item == "string")
  655.          {
  656.             return String(item);
  657.          }
  658.          try
  659.          {
  660.             return item.toString();
  661.          }
  662.          catch(e:Error)
  663.          {
  664.          }
  665.          return " ";
  666.       }
  667.       
  668.       [Bindable("dataChange")]
  669.       public function get data() : Object
  670.       {
  671.          return _data;
  672.       }
  673.       
  674.       mx_internal function onTweenUpdate(param1:Number) : void
  675.       {
  676.          if(_dropdown)
  677.          {
  678.             _dropdown.scrollRect = new Rectangle(0,param1,_dropdown.width,_dropdown.height);
  679.          }
  680.       }
  681.       
  682.       private function removedFromStageHandler(param1:Event) : void
  683.       {
  684.          destroyDropdown();
  685.       }
  686.       
  687.       private function dropdown_mouseOutsideHandler(param1:Event) : void
  688.       {
  689.          var _loc2_:MouseEvent = null;
  690.          if(param1 is MouseEvent)
  691.          {
  692.             _loc2_ = MouseEvent(param1);
  693.             if(_loc2_.target != _dropdown)
  694.             {
  695.                return;
  696.             }
  697.             if(!hitTestPoint(_loc2_.stageX,_loc2_.stageY,true))
  698.             {
  699.                close(param1);
  700.             }
  701.          }
  702.          else if(param1 is SandboxMouseEvent)
  703.          {
  704.             close(param1);
  705.          }
  706.       }
  707.       
  708.       [Bindable("dropdownFactoryChanged")]
  709.       public function get dropdownFactory() : IFactory
  710.       {
  711.          return _dropdownFactory;
  712.       }
  713.       
  714.       override public function styleChanged(param1:String) : void
  715.       {
  716.          destroyDropdown();
  717.          super.styleChanged(param1);
  718.       }
  719.       
  720.       public function set prompt(param1:String) : void
  721.       {
  722.          _prompt = param1;
  723.          promptChanged = true;
  724.          invalidateProperties();
  725.       }
  726.       
  727.       override protected function commitProperties() : void
  728.       {
  729.          explicitText = mx_internal::textChanged;
  730.          super.commitProperties();
  731.          if(collectionChanged)
  732.          {
  733.             if(selectedIndex == -1 && implicitSelectedIndex && _prompt == null)
  734.             {
  735.                selectedIndex = 0;
  736.             }
  737.             mx_internal::selectedIndexChanged = true;
  738.             collectionChanged = false;
  739.          }
  740.          if(promptChanged && prompt != null && selectedIndex == -1)
  741.          {
  742.             promptChanged = false;
  743.             textInput.text = prompt;
  744.          }
  745.       }
  746.       
  747.       mx_internal function hasDropdown() : Boolean
  748.       {
  749.          return _dropdown != null;
  750.       }
  751.       
  752.       public function set listData(param1:BaseListData) : void
  753.       {
  754.          _listData = param1;
  755.       }
  756.       
  757.       public function set labelField(param1:String) : void
  758.       {
  759.          _labelField = param1;
  760.          labelFieldChanged = true;
  761.          invalidateDisplayList();
  762.          dispatchEvent(new Event("labelFieldChanged"));
  763.       }
  764.       
  765.       public function set labelFunction(param1:Function) : void
  766.       {
  767.          _labelFunction = param1;
  768.          labelFunctionChanged = true;
  769.          invalidateDisplayList();
  770.          dispatchEvent(new Event("labelFunctionChanged"));
  771.       }
  772.       
  773.       protected function get dropDownStyleFilters() : Object
  774.       {
  775.          return null;
  776.       }
  777.       
  778.       public function set rowCount(param1:int) : void
  779.       {
  780.          _rowCount = param1;
  781.          if(_dropdown)
  782.          {
  783.             _dropdown.rowCount = param1;
  784.          }
  785.       }
  786.       
  787.       private function dropdown_changeHandler(param1:Event) : void
  788.       {
  789.          var _loc2_:int = selectedIndex;
  790.          if(_dropdown)
  791.          {
  792.             selectedIndex = _dropdown.selectedIndex;
  793.          }
  794.          if(!_showingDropdown)
  795.          {
  796.             dispatchChangeEvent(param1,_loc2_,selectedIndex);
  797.          }
  798.          else if(!bInKeyDown)
  799.          {
  800.             close();
  801.          }
  802.       }
  803.       
  804.       private function dropdown_itemClickHandler(param1:ListEvent) : void
  805.       {
  806.          if(_showingDropdown)
  807.          {
  808.             close();
  809.          }
  810.       }
  811.       
  812.       [Bindable("labelFunctionChanged")]
  813.       public function get labelFunction() : Function
  814.       {
  815.          return _labelFunction;
  816.       }
  817.       
  818.       [Bindable("valueCommit")]
  819.       [Bindable("collectionChange")]
  820.       [Bindable("change")]
  821.       override public function set selectedIndex(param1:int) : void
  822.       {
  823.          super.selectedIndex = param1;
  824.          if(param1 >= 0)
  825.          {
  826.             mx_internal::selectionChanged = true;
  827.          }
  828.          implicitSelectedIndex = false;
  829.          invalidateDisplayList();
  830.          if(textInput && !mx_internal::textChanged && param1 >= 0)
  831.          {
  832.             textInput.text = selectedLabel;
  833.          }
  834.          else if(Boolean(textInput) && Boolean(prompt))
  835.          {
  836.             textInput.text = prompt;
  837.          }
  838.       }
  839.       
  840.       private function dispatchChangeEvent(param1:Event, param2:int, param3:int) : void
  841.       {
  842.          var _loc4_:Event = null;
  843.          if(param2 != param3)
  844.          {
  845.             _loc4_ = param1 is ListEvent ? param1 : new ListEvent("change");
  846.             dispatchEvent(_loc4_);
  847.          }
  848.       }
  849.       
  850.       private function displayDropdown(param1:Boolean, param2:Event = null) : void
  851.       {
  852.          var _loc3_:Number = NaN;
  853.          var _loc4_:Number = NaN;
  854.          var _loc5_:Number = NaN;
  855.          var _loc6_:Function = null;
  856.          var _loc10_:Rectangle = null;
  857.          var _loc11_:InterManagerRequest = null;
  858.          var _loc12_:int = 0;
  859.          var _loc13_:Number = NaN;
  860.          if(!initialized || param1 == _showingDropdown)
  861.          {
  862.             return;
  863.          }
  864.          var _loc7_:Point = new Point(0,unscaledHeight);
  865.          _loc7_ = localToGlobal(_loc7_);
  866.          var _loc8_:ISystemManager = systemManager.topLevelSystemManager;
  867.          var _loc9_:DisplayObject = _loc8_.getSandboxRoot();
  868.          if(_loc8_ != _loc9_)
  869.          {
  870.             _loc11_ = new InterManagerRequest(InterManagerRequest.SYSTEM_MANAGER_REQUEST,false,false,"getVisibleApplicationRect");
  871.             _loc9_.dispatchEvent(_loc11_);
  872.             _loc10_ = Rectangle(_loc11_.value);
  873.          }
  874.          else
  875.          {
  876.             _loc10_ = _loc8_.getVisibleApplicationRect();
  877.          }
  878.          if(param1)
  879.          {
  880.             _selectedIndexOnDropdown = selectedIndex;
  881.             getDropdown();
  882.             _dropdown.addEventListener(FlexMouseEvent.MOUSE_DOWN_OUTSIDE,dropdown_mouseOutsideHandler);
  883.             _dropdown.addEventListener(FlexMouseEvent.MOUSE_WHEEL_OUTSIDE,dropdown_mouseOutsideHandler);
  884.             _dropdown.addEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE,dropdown_mouseOutsideHandler);
  885.             _dropdown.addEventListener(SandboxMouseEvent.MOUSE_WHEEL_SOMEWHERE,dropdown_mouseOutsideHandler);
  886.             if(_dropdown.parent == null)
  887.             {
  888.                PopUpManager.addPopUp(_dropdown,this);
  889.             }
  890.             else
  891.             {
  892.                PopUpManager.bringToFront(_dropdown);
  893.             }
  894.             if(_loc7_.y + _dropdown.height > _loc10_.bottom && _loc7_.y > _loc10_.top + _dropdown.height)
  895.             {
  896.                _loc7_.y -= unscaledHeight + _dropdown.height;
  897.                _loc3_ = -_dropdown.height;
  898.                tweenUp = true;
  899.             }
  900.             else
  901.             {
  902.                _loc3_ = _dropdown.height;
  903.                tweenUp = false;
  904.             }
  905.             _loc7_ = _dropdown.parent.globalToLocal(_loc7_);
  906.             _loc12_ = _dropdown.selectedIndex;
  907.             if(_loc12_ == -1)
  908.             {
  909.                _loc12_ = 0;
  910.             }
  911.             _loc13_ = _dropdown.verticalScrollPosition;
  912.             _loc13_ = _loc12_ - 1;
  913.             _loc13_ = Math.min(Math.max(_loc13_,0),_dropdown.maxVerticalScrollPosition);
  914.             _dropdown.verticalScrollPosition = _loc13_;
  915.             if(_dropdown.x != _loc7_.x || _dropdown.y != _loc7_.y)
  916.             {
  917.                _dropdown.move(_loc7_.x,_loc7_.y);
  918.             }
  919.             _dropdown.scrollRect = new Rectangle(0,_loc3_,_dropdown.width,_dropdown.height);
  920.             if(!_dropdown.visible)
  921.             {
  922.                _dropdown.visible = true;
  923.             }
  924.             bRemoveDropdown = false;
  925.             _showingDropdown = param1;
  926.             _loc5_ = getStyle("openDuration");
  927.             _loc4_ = 0;
  928.             _loc6_ = getStyle("openEasingFunction") as Function;
  929.          }
  930.          else if(_dropdown)
  931.          {
  932.             _loc4_ = _loc7_.y + _dropdown.height > _loc10_.bottom || tweenUp ? -_dropdown.height : _dropdown.height;
  933.             _showingDropdown = param1;
  934.             _loc3_ = 0;
  935.             _loc5_ = getStyle("closeDuration");
  936.             _loc6_ = getStyle("closeEasingFunction") as Function;
  937.             _dropdown.mx_internal::resetDragScrolling();
  938.          }
  939.          inTween = true;
  940.          UIComponentGlobals.mx_internal::layoutManager.validateNow();
  941.          UIComponent.suspendBackgroundProcessing();
  942.          if(_dropdown)
  943.          {
  944.             _dropdown.enabled = false;
  945.          }
  946.          _loc5_ = Math.max(1,_loc5_);
  947.          tween = new Tween(this,_loc3_,_loc4_,_loc5_);
  948.          if(_loc6_ != null && Boolean(tween))
  949.          {
  950.             tween.easingFunction = _loc6_;
  951.          }
  952.          triggerEvent = param2;
  953.       }
  954.       
  955.       public function get itemRenderer() : IFactory
  956.       {
  957.          return _itemRenderer;
  958.       }
  959.       
  960.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  961.       {
  962.          super.updateDisplayList(param1,param2);
  963.          if(Boolean(_dropdown) && !inTween)
  964.          {
  965.             destroyDropdown();
  966.          }
  967.          else if(!_showingDropdown && inTween)
  968.          {
  969.             bRemoveDropdown = true;
  970.          }
  971.          var _loc3_:Number = preferredDropdownWidth;
  972.          if(isNaN(_loc3_))
  973.          {
  974.             _loc3_ = _dropdownWidth = param1;
  975.          }
  976.          if(labelFieldChanged)
  977.          {
  978.             if(_dropdown)
  979.             {
  980.                _dropdown.labelField = _labelField;
  981.             }
  982.             mx_internal::selectionChanged = true;
  983.             if(!explicitText)
  984.             {
  985.                textInput.text = selectedLabel;
  986.             }
  987.             labelFieldChanged = false;
  988.          }
  989.          if(labelFunctionChanged)
  990.          {
  991.             if(_dropdown)
  992.             {
  993.                _dropdown.labelFunction = _labelFunction;
  994.             }
  995.             mx_internal::selectionChanged = true;
  996.             if(!explicitText)
  997.             {
  998.                textInput.text = selectedLabel;
  999.             }
  1000.             labelFunctionChanged = false;
  1001.          }
  1002.          if(mx_internal::selectionChanged)
  1003.          {
  1004.             if(!mx_internal::textChanged)
  1005.             {
  1006.                if(selectedIndex == -1 && Boolean(prompt))
  1007.                {
  1008.                   textInput.text = prompt;
  1009.                }
  1010.                else if(!explicitText)
  1011.                {
  1012.                   textInput.text = selectedLabel;
  1013.                }
  1014.             }
  1015.             textInput.invalidateDisplayList();
  1016.             textInput.validateNow();
  1017.             if(editable)
  1018.             {
  1019.                textInput.mx_internal::getTextField().setSelection(0,textInput.text.length);
  1020.                textInput.mx_internal::getTextField().scrollH = 0;
  1021.             }
  1022.             if(_dropdown)
  1023.             {
  1024.                _dropdown.selectedIndex = selectedIndex;
  1025.             }
  1026.             mx_internal::selectionChanged = false;
  1027.          }
  1028.          if(Boolean(_dropdown) && _dropdown.rowCount != rowCount)
  1029.          {
  1030.             _dropdown.rowCount = rowCount;
  1031.          }
  1032.       }
  1033.       
  1034.       public function close(param1:Event = null) : void
  1035.       {
  1036.          if(_showingDropdown)
  1037.          {
  1038.             if(Boolean(_dropdown) && selectedIndex != _dropdown.selectedIndex)
  1039.             {
  1040.                selectedIndex = _dropdown.selectedIndex;
  1041.             }
  1042.             displayDropdown(false,param1);
  1043.             dispatchChangeEvent(new Event("dummy"),_selectedIndexOnDropdown,selectedIndex);
  1044.          }
  1045.       }
  1046.       
  1047.       public function set itemRenderer(param1:IFactory) : void
  1048.       {
  1049.          _itemRenderer = param1;
  1050.          if(_dropdown)
  1051.          {
  1052.             _dropdown.itemRenderer = param1;
  1053.          }
  1054.          invalidateSize();
  1055.          invalidateDisplayList();
  1056.          dispatchEvent(new Event("itemRendererChanged"));
  1057.       }
  1058.       
  1059.       override public function set showInAutomationHierarchy(param1:Boolean) : void
  1060.       {
  1061.       }
  1062.    }
  1063. }
  1064.  
  1065.